home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / lalr.lha / lalr / m2c / Debug.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  39KB  |  1,471 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Automaton
  4. #include "Automaton.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Continue
  8. #include "Continue.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_DynArray
  12. #include "DynArray.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_IO
  16. #include "IO.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Sets
  20. #include "Sets.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Strings
  24. #include "Strings.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Idents
  28. #include "Idents.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_TokenTab
  32. #include "TokenTab.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Debug
  36. #include "Debug.h"
  37. #endif
  38.  
  39. BOOLEAN Debug_NoTrace;
  40. IO_tFile Debug_dFile;
  41.  
  42. #define InitTab    0
  43. #define MaxTabA    40
  44. #define MaxTabB    30
  45. #define MaxTabC    50
  46. #define MaxTabD    40
  47. #define InitChainLength    50
  48. typedef struct S_1 {
  49.     SHORTCARD count;
  50.     LONGINT max;
  51.     struct S_6 {
  52.         Automaton_tItemIndex A[Automaton_Infinite - 1 + 1];
  53.     } *path;
  54. } tItemPath;
  55. typedef struct S_2 {
  56.     Automaton_tProdIndex Prod;
  57.     Automaton_tIndex Pos;
  58. } tProdPathElmt;
  59. typedef struct S_3 {
  60.     SHORTCARD count;
  61.     LONGINT max;
  62.     struct S_7 {
  63.         tProdPathElmt A[Automaton_Infinite - 1 + 1];
  64.     } *path;
  65. } tProdPath;
  66. typedef struct S_4 {
  67.     Automaton_tItemIndex Item;
  68.     Automaton_tIndex Last;
  69. } tItemChainElmt;
  70. typedef struct S_5 {
  71.     Sets_tSet reached;
  72.     LONGINT level;
  73.     LONGINT count;
  74.     LONGINT max;
  75.     struct S_8 {
  76.         tItemChainElmt A[Automaton_Infinite - 1 + 1];
  77.     } *chain;
  78. } tItemChain;
  79. static tProdPath PathA;
  80. static tItemPath PathC;
  81. static tItemPath PathB;
  82. static tItemChain ChainD;
  83. static tProdPath PathD;
  84. static void WriteItem ARGS((Automaton_tItemIndex Item, TokenTab_Terminal t));
  85. static void DebugRedItem ARGS((Automaton_tStateIndex State, Sets_tSet *CS, Automaton_tItemIndex Item, Sets_tSet *EI));
  86. static BOOLEAN Possible ARGS((Automaton_tItemIndex Item, TokenTab_Terminal t));
  87. #define yes    0
  88. #define no    1
  89. #define maybe    2
  90. typedef unsigned char triaer;
  91. static triaer Poss ARGS((Automaton_tStateIndex state, Automaton_tProdIndex prod, Automaton_tIndex pos, CARDINAL depth));
  92. static Automaton_tRep GetRep ARGS((Automaton_tItemIndex Item));
  93. static void FindPathC ARGS((Sets_tSet *cs, Automaton_tItemIndex Item));
  94. static void SearchPathC ARGS((Sets_tSet *cs, CARDINAL maxdepth, CARDINAL depth, Automaton_tItemIndex Item, BOOLEAN *found));
  95. static void UnRepPathC ARGS(());
  96. static void WritePartA ARGS((CARDINAL *d, TokenTab_NonTerminal N));
  97. static void FindPathA ARGS((TokenTab_NonTerminal N));
  98. static void SearchPathA ARGS((TokenTab_NonTerminal From, TokenTab_NonTerminal To, CARDINAL maxdepth, CARDINAL depth, BOOLEAN *found, Sets_tSet *rNTs));
  99. static void WritePartB ARGS((CARDINAL *d, Automaton_tItemIndex I));
  100. static void WritePartC ARGS((CARDINAL *d, Automaton_tItemIndex I, TokenTab_Terminal t));
  101. static void WritePartD ARGS((CARDINAL dist, Automaton_tStateIndex State, TokenTab_Terminal t, Automaton_tItemIndex RedItem, Sets_tSet EI));
  102. static void MakeChainD ARGS(());
  103. static void PutInChain ARGS((Automaton_tItemIndex Item, Automaton_tIndex Last));
  104. static void FindPathD ARGS((TokenTab_NonTerminal NT, Automaton_tStateIndex EndState));
  105. static void WriteProd ARGS((Automaton_tProdIndex p, Automaton_tIndex l, CARDINAL *d));
  106. static void WriteVoc ARGS((TokenTab_Vocabulary voc, CARDINAL *length));
  107. static CARDINAL VocLength ARGS((TokenTab_Vocabulary voc));
  108. static void WriteTab ARGS((CARDINAL d));
  109.  
  110. static Sets_tSet *G_1_reached;
  111. static TokenTab_Terminal *G_2_t;
  112.  
  113. void Debug_InformIgnored
  114. # ifdef __STDC__
  115. (Automaton_tItemIndex Item, TokenTab_Terminal t)
  116. # else
  117. (Item, t)
  118. Automaton_tItemIndex Item;
  119. TokenTab_Terminal t;
  120. # endif
  121. {
  122.   IO_WriteS(Debug_dFile, (STRING)"ignored                 ", 24L);
  123.   WriteItem(Item, t);
  124. }
  125.  
  126. void Debug_InformLowPri
  127. # ifdef __STDC__
  128. (Automaton_tItemIndex Item, TokenTab_Terminal t)
  129. # else
  130. (Item, t)
  131. Automaton_tItemIndex Item;
  132. TokenTab_Terminal t;
  133. # endif
  134. {
  135.   IO_WriteS(Debug_dFile, (STRING)"ignored (precedence)    ", 24L);
  136.   WriteItem(Item, t);
  137. }
  138.  
  139. void Debug_InformRightAss
  140. # ifdef __STDC__
  141. (Automaton_tItemIndex Item, TokenTab_Terminal t)
  142. # else
  143. (Item, t)
  144. Automaton_tItemIndex Item;
  145. TokenTab_Terminal t;
  146. # endif
  147. {
  148.   IO_WriteS(Debug_dFile, (STRING)"ignored (associativity) ", 24L);
  149.   WriteItem(Item, t);
  150. }
  151.  
  152. void Debug_InformLeftAss
  153. # ifdef __STDC__
  154. (Automaton_tItemIndex Item, TokenTab_Terminal t)
  155. # else
  156. (Item, t)
  157. Automaton_tItemIndex Item;
  158. TokenTab_Terminal t;
  159. # endif
  160. {
  161.   IO_WriteS(Debug_dFile, (STRING)"ignored (associativity) ", 24L);
  162.   WriteItem(Item, t);
  163. }
  164.  
  165. void Debug_InformKept
  166. # ifdef __STDC__
  167. (Automaton_tItemIndex Item, TokenTab_Terminal t)
  168. # else
  169. (Item, t)
  170. Automaton_tItemIndex Item;
  171. TokenTab_Terminal t;
  172. # endif
  173. {
  174.   IO_WriteS(Debug_dFile, (STRING)"retained                ", 24L);
  175.   WriteItem(Item, t);
  176. }
  177.  
  178. void Debug_InformConflict
  179. # ifdef __STDC__
  180. (Debug_tConflict kind)
  181. # else
  182. (kind)
  183. Debug_tConflict kind;
  184. # endif
  185. {
  186.   switch (kind) {
  187.   case Debug_ShRed:;
  188.     IO_WriteS(Debug_dFile, (STRING)"there is a read reduce conflict", 31L);
  189.     break;
  190.   case Debug_RedRed:;
  191.     IO_WriteS(Debug_dFile, (STRING)"there is a reduce reduce conflict", 33L);
  192.     break;
  193.   case Debug_ShRedRed:;
  194.     IO_WriteS(Debug_dFile, (STRING)"there is a read-reduce-reduce conflict", 38L);
  195.     break;
  196.   default :
  197.     break;
  198.   }
  199.   IO_WriteNl(Debug_dFile);
  200. }
  201.  
  202. void Debug_NewLine
  203. # ifdef __STDC__
  204. ()
  205. # else
  206. ()
  207. # endif
  208. {
  209.   IO_WriteNl(Debug_dFile);
  210. }
  211.  
  212. static void WriteItem
  213. # ifdef __STDC__
  214. (Automaton_tItemIndex Item, TokenTab_Terminal t)
  215. # else
  216. (Item, t)
  217. Automaton_tItemIndex Item;
  218. TokenTab_Terminal t;
  219. # endif
  220. {
  221.   CARDINAL length;
  222.   Automaton_tIndex i;
  223.   Automaton_tProduction p;
  224.  
  225.   {
  226.     register Automaton_tItem *W_1 = &Automaton_ItemArrayPtr->A[Item - 1];
  227.  
  228.     p = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_1->Prod]);
  229.     WriteVoc(p->Left, &length);
  230.     IO_WriteS(Debug_dFile, (STRING)" -> ", 4L);
  231.     length = 0;
  232.     {
  233.       register struct Automaton_9 *W_2 = p;
  234.  
  235.       if (W_2->Len == 0) {
  236.         IO_WriteS(Debug_dFile, (STRING)"-Epsilon-.", 10L);
  237.       } else {
  238.         if (W_1->Pos == 0) {
  239.           IO_WriteS(Debug_dFile, (STRING)".", 1L);
  240.         }
  241.         {
  242.           LONGCARD B_1 = 1, B_2 = W_2->Len;
  243.  
  244.           if (B_1 <= B_2)
  245.             for (i = B_1;; i += 1) {
  246.               WriteVoc(W_2->Right.A[i - 1], &length);
  247.               if (W_1->Pos == i) {
  248.                 IO_WriteS(Debug_dFile, (STRING)".", 1L);
  249.               } else {
  250.                 IO_WriteS(Debug_dFile, (STRING)" ", 1L);
  251.               }
  252.               if (i >= B_2) break;
  253.             }
  254.         }
  255.       }
  256.     }
  257.     if (W_1->Pos == p->Len) {
  258.       IO_WriteS(Debug_dFile, (STRING)" {", 2L);
  259.       WriteVoc(t, &length);
  260.       IO_WriteS(Debug_dFile, (STRING)"}", 1L);
  261.     }
  262.     IO_WriteNl(Debug_dFile);
  263.   }
  264. }
  265.  
  266. void Debug_DebugHead
  267. # ifdef __STDC__
  268. (Automaton_tStateIndex State)
  269. # else
  270. (State)
  271. Automaton_tStateIndex State;
  272. # endif
  273. {
  274.   if (Debug_NoTrace) {
  275.     return;
  276.   }
  277.   IO_WriteS(Debug_dFile, (STRING)"State ", 6L);
  278.   IO_WriteI(Debug_dFile, (LONGINT)State, 1L);
  279.   IO_WriteNl(Debug_dFile);
  280.   IO_WriteNl(Debug_dFile);
  281. }
  282.  
  283. void Debug_DebugEnd
  284. # ifdef __STDC__
  285. ()
  286. # else
  287. ()
  288. # endif
  289. {
  290.   if (Debug_NoTrace) {
  291.     return;
  292.   }
  293.   IO_WriteNl(Debug_dFile);
  294. }
  295.  
  296. void Debug_DebugState
  297. # ifdef __STDC__
  298. (Automaton_tStateIndex State, Sets_tSet *CS)
  299. # else
  300. (State, CS)
  301. Automaton_tStateIndex State;
  302. Sets_tSet *CS;
  303. # endif
  304. {
  305.   Automaton_tItemIndex Item;
  306.   Sets_tSet s;
  307.   Sets_tSet EI;
  308.  
  309.   if (Debug_NoTrace) {
  310.     return;
  311.   }
  312.   IO_WriteNl(Debug_dFile);
  313.   Sets_MakeSet(&s, (LONGCARD)TokenTab_MAXTerm);
  314.   {
  315.     register Automaton_tState *W_3 = &Automaton_StateArrayPtr->A[State - 1];
  316.  
  317.     Sets_MakeSet(&EI, W_3->Size - 1);
  318.     {
  319.       LONGCARD B_3 = W_3->Items, B_4 = W_3->Items + W_3->Size - 1;
  320.  
  321.       if (B_3 <= B_4)
  322.         for (Item = B_3;; Item += 1) {
  323.           {
  324.             register Automaton_tItem *W_4 = &Automaton_ItemArrayPtr->A[Item - 1];
  325.  
  326.             if (W_4->Rep == Automaton_RedRep) {
  327.               Sets_Assign(&s, *CS);
  328.               Sets_Intersection(&s, W_4->Set);
  329.               if (!Sets_IsEmpty(s)) {
  330.                 DebugRedItem(State, CS, Item, &EI);
  331.               }
  332.             }
  333.           }
  334.           if (Item >= B_4) break;
  335.         }
  336.     }
  337.     Sets_ReleaseSet(&EI);
  338.   }
  339.   Sets_ReleaseSet(&s);
  340. }
  341.  
  342. static void DebugRedItem
  343. # ifdef __STDC__
  344. (Automaton_tStateIndex State, Sets_tSet *CS, Automaton_tItemIndex Item, Sets_tSet *EI)
  345. # else
  346. (State, CS, Item, EI)
  347. Automaton_tStateIndex State;
  348. Sets_tSet *CS;
  349. Automaton_tItemIndex Item;
  350. Sets_tSet *EI;
  351. # endif
  352. {
  353.   Sets_tSet T;
  354.   Sets_tSet cs;
  355.   Automaton_tItemIndex i;
  356.   Automaton_tItemIndex I;
  357.   CARDINAL d;
  358.   TokenTab_Terminal t;
  359.   Automaton_tProduction prod;
  360.  
  361.   Sets_MakeSet(&cs, (LONGCARD)TokenTab_MAXTerm);
  362.   Sets_Assign(&cs, *CS);
  363.   FindPathC(&cs, Item);
  364.   UnRepPathC();
  365.   Sets_MakeSet(&T, (LONGCARD)TokenTab_MAXTerm);
  366.   i = PathC.path->A[PathC.count - 1];
  367.   while (!Sets_IsEmpty(cs)) {
  368.     t = Sets_Extract(&cs);
  369.     {
  370.       register Automaton_tItem *W_5 = &Automaton_ItemArrayPtr->A[i - 1];
  371.  
  372.       {
  373.         register Automaton_tState *W_6 = &Automaton_StateArrayPtr->A[W_5->Next - 1];
  374.  
  375.         I = W_6->Items;
  376.         for (;;) {
  377.           if (I >= W_6->Items + W_6->Size) {
  378.             goto EXIT_1;
  379.           }
  380.           if (Possible(I, t)) {
  381.             d = InitTab;
  382.             prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[Automaton_ItemArrayPtr->A[I - 1].Prod]);
  383.             WritePartA(&d, prod->Left);
  384.             WritePartB(&d, I);
  385.             WritePartC(&d, Item, t);
  386.             WritePartD(d, State, t, Item, *EI);
  387.             IO_WriteNl(Debug_dFile);
  388.             IO_WriteNl(Debug_dFile);
  389.             DynArray_ReleaseArray((ADDRESS *)&PathB.path, &PathB.max, (LONGINT)sizeof(Automaton_tItemIndex));
  390.             goto EXIT_1;
  391.           }
  392.           INC(I);
  393.         } EXIT_1:;
  394.       }
  395.     }
  396.   }
  397.   Sets_ReleaseSet(&T);
  398.   Sets_ReleaseSet(&cs);
  399.   DynArray_ReleaseArray((ADDRESS *)&PathC.path, &PathC.max, (LONGINT)sizeof(Automaton_tItemIndex));
  400. }
  401.  
  402. static triaer Poss
  403. # ifdef __STDC__
  404. (Automaton_tStateIndex state, Automaton_tProdIndex prod, Automaton_tIndex pos, CARDINAL depth)
  405. # else
  406. (state, prod, pos, depth)
  407. Automaton_tStateIndex state;
  408. Automaton_tProdIndex prod;
  409. Automaton_tIndex pos;
  410. CARDINAL depth;
  411. # endif
  412. {
  413.   triaer res;
  414.   TokenTab_NonTerminal nt;
  415.   Automaton_tItemIndex item;
  416.   Automaton_tItemIndex Item;
  417.   Automaton_tProduction production;
  418.  
  419.   {
  420.     register Automaton_tState *W_7 = &Automaton_StateArrayPtr->A[state - 1];
  421.  
  422.     Item = W_7->Items;
  423.     for (;;) {
  424.       {
  425.         register Automaton_tItem *W_8 = &Automaton_ItemArrayPtr->A[Item - 1];
  426.  
  427.         if (W_8->Prod == prod && W_8->Pos == pos) {
  428.           goto EXIT_2;
  429.         }
  430.         INC(Item);
  431.       }
  432.     } EXIT_2:;
  433.   }
  434.   if (Sets_IsElement(Item, G_1_reached)) {
  435.     return no;
  436.   }
  437.   Sets_Include(G_1_reached, Item);
  438.   {
  439.     register Automaton_tItem *W_9 = &Automaton_ItemArrayPtr->A[Item - 1];
  440.  
  441.     switch (GetRep(Item)) {
  442.     case Automaton_TermRep:;
  443.       if (*G_2_t == W_9->Read) {
  444.         PathB.count = depth;
  445.         PathB.max = depth;
  446.         DynArray_MakeArray((ADDRESS *)&PathB.path, &PathB.max, (LONGINT)sizeof(Automaton_tItemIndex));
  447.         PathB.path->A[depth - 1] = Item;
  448.         Sets_Exclude(G_1_reached, Item);
  449.         return yes;
  450.       } else {
  451.         Sets_Exclude(G_1_reached, Item);
  452.         return no;
  453.       }
  454.       break;
  455.     case Automaton_RedRep:;
  456.       Sets_Exclude(G_1_reached, Item);
  457.       return maybe;
  458.       break;
  459.     case Automaton_NonTermRep:;
  460.       res = no;
  461.       nt = W_9->Read;
  462.       {
  463.         register Automaton_tState *W_10 = &Automaton_StateArrayPtr->A[state - 1];
  464.  
  465.         {
  466.           LONGCARD B_5 = W_10->Items, B_6 = W_10->Items + W_10->Size - 1;
  467.  
  468.           if (B_5 <= B_6)
  469.             for (item = B_5;; item += 1) {
  470.               {
  471.                 register Automaton_tItem *W_11 = &Automaton_ItemArrayPtr->A[item - 1];
  472.  
  473.                 production = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_11->Prod]);
  474.                 if (production->Left == nt) {
  475.                   switch (Poss(state, W_11->Prod, W_11->Pos, depth + 1)) {
  476.                   case yes:;
  477.                     PathB.path->A[depth - 1] = Item;
  478.                     Sets_Exclude(G_1_reached, Item);
  479.                     return yes;
  480.                     break;
  481.                   case no:;
  482.                     break;
  483.                   case maybe:;
  484.                     switch (Poss(Automaton_ItemArrayPtr->A[Item - 1].Next, prod, pos + 1, depth)) {
  485.                     case yes:;
  486.                       Sets_Exclude(G_1_reached, Item);
  487.                       return yes;
  488.                       break;
  489.                     case no:;
  490.                       break;
  491.                     case maybe:;
  492.                       res = maybe;
  493.                       break;
  494.                     }
  495.                     break;
  496.                   }
  497.                 }
  498.               }
  499.               if (item >= B_6) break;
  500.             }
  501.         }
  502.       }
  503.       Sets_Exclude(G_1_reached, Item);
  504.       return res;
  505.       break;
  506.     }
  507.   }
  508. }
  509.  
  510. static Automaton_tRep GetRep
  511. # ifdef __STDC__
  512. (Automaton_tItemIndex Item)
  513. # else
  514. (Item)
  515. Automaton_tItemIndex Item;
  516. # endif
  517. {
  518.   Automaton_tProduction prod;
  519.  
  520.   {
  521.     register Automaton_tItem *W_12 = &Automaton_ItemArrayPtr->A[Item - 1];
  522.  
  523.     prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_12->Prod]);
  524.     {
  525.       register struct Automaton_9 *W_13 = prod;
  526.  
  527.       if (W_12->Pos == W_13->Len) {
  528.         return Automaton_RedRep;
  529.       } else if (W_13->Right.A[W_12->Pos + 1 - 1] >= TokenTab_MINTerm && W_13->Right.A[W_12->Pos + 1 - 1] <= TokenTab_MAXTerm) {
  530.         return Automaton_TermRep;
  531.       } else {
  532.         return Automaton_NonTermRep;
  533.       }
  534.     }
  535.   }
  536. }
  537.  
  538. static BOOLEAN Possible
  539. # ifdef __STDC__
  540. (Automaton_tItemIndex Item, TokenTab_Terminal t)
  541. # else
  542. (Item, t)
  543. Automaton_tItemIndex Item;
  544. TokenTab_Terminal t;
  545. # endif
  546. {
  547.   Automaton_tStateIndex state;
  548.   Automaton_tProdIndex prod;
  549.   Automaton_tIndex pos;
  550.   Sets_tSet reached;
  551.   Sets_tSet *L_1;
  552.   TokenTab_Terminal *L_2;
  553.  
  554.   L_1 = G_1_reached;
  555.   G_1_reached = &reached;
  556.   L_2 = G_2_t;
  557.   G_2_t = &t;
  558.   {
  559.     register Automaton_tItem *W_14 = &Automaton_ItemArrayPtr->A[Item - 1];
  560.  
  561.     state = W_14->Number;
  562.     prod = W_14->Prod;
  563.     pos = W_14->Pos;
  564.   }
  565.   Sets_MakeSet(&reached, (LONGCARD)Automaton_ItemIndex);
  566.   if (Poss(state, prod, pos, 1L) == yes) {
  567.     Sets_ReleaseSet(&reached);
  568.     G_1_reached = L_1;
  569.     G_2_t = L_2;
  570.     return TRUE;
  571.   } else {
  572.     Sets_ReleaseSet(&reached);
  573.     G_1_reached = L_1;
  574.     G_2_t = L_2;
  575.     return FALSE;
  576.   }
  577. }
  578.  
  579. static void FindPathC
  580. # ifdef __STDC__
  581. (Sets_tSet *cs, Automaton_tItemIndex Item)
  582. # else
  583. (cs, Item)
  584. Sets_tSet *cs;
  585. Automaton_tItemIndex Item;
  586. # endif
  587. {
  588.   CARDINAL maxdepth;
  589.   BOOLEAN found;
  590.   Automaton_tIndex i, u;
  591.  
  592.   maxdepth = 0;
  593.   found = FALSE;
  594.   do {
  595.     INC(maxdepth);
  596.     {
  597.       register Automaton_tItemIndexList *W_15 = &Automaton_ItemArrayPtr->A[Item - 1].Relation;
  598.  
  599.       i = 1;
  600.       u = W_15->Used;
  601.       while (i <= u && !found) {
  602.         SearchPathC(cs, maxdepth, 0L, W_15->Array->A[i - 1], &found);
  603.         INC(i);
  604.       }
  605.     }
  606.   } while (!found);
  607. }
  608.  
  609. static void SearchPathC
  610. # ifdef __STDC__
  611. (Sets_tSet *cs, CARDINAL maxdepth, CARDINAL depth, Automaton_tItemIndex Item, BOOLEAN *found)
  612. # else
  613. (cs, maxdepth, depth, Item, found)
  614. Sets_tSet *cs;
  615. CARDINAL maxdepth;
  616. CARDINAL depth;
  617. Automaton_tItemIndex Item;
  618. BOOLEAN *found;
  619. # endif
  620. {
  621.   Sets_tSet s;
  622.   Automaton_tIndex i, u;
  623.  
  624.   {
  625.     register Automaton_tItem *W_16 = &Automaton_ItemArrayPtr->A[Item - 1];
  626.  
  627.     INC(depth);
  628.     Sets_MakeSet(&s, (LONGCARD)TokenTab_MAXTerm);
  629.     if (!W_16->EmptyReadSet) {
  630.       Sets_Assign(&s, W_16->ReadSet);
  631.     }
  632.     Sets_Intersection(&s, *cs);
  633.     *found = !Sets_IsEmpty(s);
  634.     if (*found) {
  635.       Sets_Assign(cs, s);
  636.     }
  637.     Sets_ReleaseSet(&s);
  638.     if (*found) {
  639.       PathC.count = depth;
  640.       PathC.max = depth;
  641.       DynArray_MakeArray((ADDRESS *)&PathC.path, &PathC.max, (LONGINT)sizeof(Automaton_tItemIndex));
  642.       PathC.path->A[depth - 1] = Item;
  643.     } else if (depth < maxdepth) {
  644.       {
  645.         register Automaton_tItemIndexList *W_17 = &Automaton_ItemArrayPtr->A[Item - 1].Relation;
  646.  
  647.         i = 1;
  648.         u = W_17->Used;
  649.         while (i <= u && !*found) {
  650.           SearchPathC(cs, maxdepth, depth, W_17->Array->A[i - 1], found);
  651.           INC(i);
  652.         }
  653.         if (*found) {
  654.           PathC.path->A[depth - 1] = Item;
  655.         }
  656.       }
  657.     }
  658.   }
  659. }
  660.  
  661. static void UnRepPathC
  662. # ifdef __STDC__
  663. ()
  664. # else
  665. ()
  666. # endif
  667. {
  668.   Automaton_tStateIndex State;
  669.   Automaton_tItemIndex PathItem, Item;
  670.   CARDINAL i, j;
  671.   Automaton_tProduction prod;
  672.   Automaton_tIndex PathVal, val;
  673.  
  674.   {
  675.     register tItemPath *W_18 = &PathC;
  676.  
  677.     {
  678.       LONGCARD B_7 = 1, B_8 = W_18->count - 1;
  679.  
  680.       if (B_7 <= B_8)
  681.         for (i = B_7;; i += 1) {
  682.           PathItem = W_18->path->A[i - 1];
  683.           prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[Automaton_ItemArrayPtr->A[PathItem - 1].Prod]);
  684.           PathVal = 0;
  685.           {
  686.             LONGCARD B_9 = Automaton_ItemArrayPtr->A[PathItem - 1].Pos + 1, B_10 = prod->Len;
  687.  
  688.             if (B_9 <= B_10)
  689.               for (j = B_9;; j += 1) {
  690.                 INC1(PathVal, Continue_Value.A[prod->Right.A[j - 1]]);
  691.                 if (j >= B_10) break;
  692.               }
  693.           }
  694.           State = Automaton_ItemArrayPtr->A[PathItem - 1].Number;
  695.           {
  696.             register Automaton_tState *W_19 = &Automaton_StateArrayPtr->A[State - 1];
  697.  
  698.             {
  699.               LONGCARD B_11 = W_19->Items, B_12 = W_19->Items + W_19->Size - 1;
  700.  
  701.               if (B_11 <= B_12)
  702.                 for (Item = B_11;; Item += 1) {
  703.                   if (Automaton_ItemArrayPtr->A[Item - 1].RepNo == Automaton_ItemArrayPtr->A[PathItem - 1].RepNo) {
  704.                     prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[Automaton_ItemArrayPtr->A[Item - 1].Prod]);
  705.                     val = 0;
  706.                     {
  707.                       LONGCARD B_13 = Automaton_ItemArrayPtr->A[Item - 1].Pos + 1, B_14 = prod->Len;
  708.  
  709.                       if (B_13 <= B_14)
  710.                         for (j = B_13;; j += 1) {
  711.                           INC1(val, Continue_Value.A[prod->Right.A[j - 1]]);
  712.                           if (j >= B_14) break;
  713.                         }
  714.                     }
  715.                     if (val < PathVal) {
  716.                       PathItem = Item;
  717.                       PathVal = val;
  718.                     }
  719.                   }
  720.                   if (Item >= B_12) break;
  721.                 }
  722.             }
  723.           }
  724.           W_18->path->A[i - 1] = PathItem;
  725.           if (i >= B_8) break;
  726.         }
  727.     }
  728.   }
  729. }
  730.  
  731. static void WritePartA
  732. # ifdef __STDC__
  733. (CARDINAL *d, TokenTab_NonTerminal N)
  734. # else
  735. (d, N)
  736. CARDINAL *d;
  737. TokenTab_NonTerminal N;
  738. # endif
  739. {
  740.   CARDINAL i, j;
  741.  
  742.   FindPathA(N);
  743.   {
  744.     register tProdPath *W_20 = &PathA;
  745.  
  746.     {
  747.       LONGCARD B_15 = 1, B_16 = W_20->count;
  748.  
  749.       if (B_15 <= B_16)
  750.         for (i = B_15;; i += 1) {
  751.           WriteTab(*d);
  752.           WriteProd(W_20->path->A[i - 1].Prod, W_20->path->A[i - 1].Pos, d);
  753.           IO_WriteNl(Debug_dFile);
  754.           if (*d > MaxTabA || i == W_20->count && *d > InitTab) {
  755.             WriteTab((LONGCARD)InitTab);
  756.             {
  757.               LONGCARD B_17 = InitTab + 1, B_18 = *d;
  758.  
  759.               if (B_17 <= B_18)
  760.                 for (j = B_17;; j += 1) {
  761.                   IO_WriteC(Debug_dFile, '.');
  762.                   if (j >= B_18) break;
  763.                 }
  764.             }
  765.             IO_WriteC(Debug_dFile, ':');
  766.             IO_WriteNl(Debug_dFile);
  767.             *d = InitTab;
  768.             WriteTab(*d);
  769.             IO_WriteC(Debug_dFile, ':');
  770.             IO_WriteNl(Debug_dFile);
  771.           }
  772.           if (i >= B_16) break;
  773.         }
  774.     }
  775.   }
  776.   DynArray_ReleaseArray((ADDRESS *)&PathA.path, &PathA.max, (LONGINT)sizeof(tProdPathElmt));
  777. }
  778.  
  779. static void FindPathA
  780. # ifdef __STDC__
  781. (TokenTab_NonTerminal N)
  782. # else
  783. (N)
  784. TokenTab_NonTerminal N;
  785. # endif
  786. {
  787.   CARDINAL maxdepth;
  788.   BOOLEAN found;
  789.   Sets_tSet rNTs;
  790.  
  791.   maxdepth = 0;
  792.   found = FALSE;
  793.   Sets_MakeSet(&rNTs, (LONGCARD)TokenTab_MAXNonTerm);
  794.   do {
  795.     INC(maxdepth);
  796.     SearchPathA(Automaton_StartSymbol, N, maxdepth, 0L, &found, &rNTs);
  797.   } while (!found);
  798.   Sets_ReleaseSet(&rNTs);
  799. }
  800.  
  801. static void SearchPathA
  802. # ifdef __STDC__
  803. (TokenTab_NonTerminal From, TokenTab_NonTerminal To, CARDINAL maxdepth, CARDINAL depth, BOOLEAN *found, Sets_tSet *rNTs)
  804. # else
  805. (From, To, maxdepth, depth, found, rNTs)
  806. TokenTab_NonTerminal From;
  807. TokenTab_NonTerminal To;
  808. CARDINAL maxdepth;
  809. CARDINAL depth;
  810. BOOLEAN *found;
  811. Sets_tSet *rNTs;
  812. # endif
  813. {
  814.   Automaton_tProduction prod;
  815.   Automaton_tProdIndex prodindex;
  816.   Automaton_tIndex pos;
  817.   Automaton_tIndex i, u;
  818.  
  819.   if (From == To) {
  820.     {
  821.       register tProdPath *W_21 = &PathA;
  822.  
  823.       W_21->count = depth;
  824.       W_21->max = depth;
  825.       DynArray_MakeArray((ADDRESS *)&W_21->path, &W_21->max, (LONGINT)sizeof(tProdPathElmt));
  826.       *found = TRUE;
  827.     }
  828.   } else if (depth < maxdepth) {
  829.     {
  830.       register Automaton_tProdIndexList *W_22 = &Automaton_ProdList.A[From - 1001];
  831.  
  832.       u = W_22->Used;
  833.       {
  834.         LONGCARD B_19 = 1, B_20 = u;
  835.  
  836.         if (B_19 <= B_20)
  837.           for (i = B_19;; i += 1) {
  838.             prodindex = W_22->Array->A[i - 1].Index;
  839.             prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[prodindex]);
  840.             {
  841.               register struct Automaton_9 *W_23 = prod;
  842.  
  843.               {
  844.                 LONGCARD B_21 = 1, B_22 = W_23->Len;
  845.  
  846.                 if (B_21 <= B_22)
  847.                   for (pos = B_21;; pos += 1) {
  848.                     if (W_23->Right.A[pos - 1] >= TokenTab_MINNonTerm && W_23->Right.A[pos - 1] <= TokenTab_MAXNonTerm) {
  849.                       if (!Sets_IsElement((LONGCARD)W_23->Right.A[pos - 1], rNTs)) {
  850.                         Sets_Include(rNTs, (LONGCARD)W_23->Right.A[pos - 1]);
  851.                         SearchPathA(W_23->Right.A[pos - 1], To, maxdepth, depth + 1, found, rNTs);
  852.                         Sets_Exclude(rNTs, (LONGCARD)W_23->Right.A[pos - 1]);
  853.                       }
  854.                       if (*found) {
  855.                         PathA.path->A[depth + 1 - 1].Prod = prodindex;
  856.                         PathA.path->A[depth + 1 - 1].Pos = pos - 1;
  857.                         return;
  858.                       }
  859.                     }
  860.                     if (pos >= B_22) break;
  861.                   }
  862.               }
  863.             }
  864.             if (i >= B_20) break;
  865.           }
  866.       }
  867.     }
  868.   }
  869. }
  870.  
  871. static void WritePartB
  872. # ifdef __STDC__
  873. (CARDINAL *d, Automaton_tItemIndex I)
  874. # else
  875. (d, I)
  876. CARDINAL *d;
  877. Automaton_tItemIndex I;
  878. # endif
  879. {
  880.   Automaton_tProdIndex p;
  881.   Automaton_tIndex l;
  882.   Automaton_tIndex l1;
  883.   CARDINAL length;
  884.   CARDINAL i, j;
  885.   CARDINAL d1;
  886.   Automaton_tProduction prod;
  887.  
  888.   p = Automaton_ItemArrayPtr->A[I - 1].Prod;
  889.   l = Automaton_ItemArrayPtr->A[I - 1].Pos - 1;
  890.   l1 = Automaton_ItemArrayPtr->A[PathB.path->A[1 - 1] - 1].Pos;
  891.   d1 = 0;
  892.   WriteTab(*d);
  893.   prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[p]);
  894.   {
  895.     register struct Automaton_9 *W_24 = prod;
  896.  
  897.     {
  898.       LONGCARD B_23 = 1, B_24 = W_24->Len;
  899.  
  900.       if (B_23 <= B_24)
  901.         for (i = B_23;; i += 1) {
  902.           WriteVoc(W_24->Right.A[i - 1], &length);
  903.           IO_WriteS(Debug_dFile, (STRING)" ", 1L);
  904.           if (i <= l) {
  905.             INC1(*d, length + 1);
  906.           } else if (i <= l1) {
  907.             INC1(d1, length + 1);
  908.           }
  909.           if (i >= B_24) break;
  910.         }
  911.     }
  912.   }
  913.   DEC(d1);
  914.   IO_WriteNl(Debug_dFile);
  915.   {
  916.     register tItemPath *W_25 = &PathB;
  917.  
  918.     {
  919.       LONGCARD B_25 = 2, B_26 = W_25->count;
  920.  
  921.       if (B_25 <= B_26)
  922.         for (i = B_25;; i += 1) {
  923.           if (*d + d1 + 1 > MaxTabB && d1 > 1) {
  924.             WriteTab(*d);
  925.             IO_WriteS(Debug_dFile, (STRING)": ", 2L);
  926.             {
  927.               LONGCARD B_27 = 2, B_28 = d1;
  928.  
  929.               if (B_27 <= B_28)
  930.                 for (j = B_27;; j += 1) {
  931.                   IO_WriteC(Debug_dFile, '.');
  932.                   if (j >= B_28) break;
  933.                 }
  934.             }
  935.             IO_WriteC(Debug_dFile, ':');
  936.             IO_WriteNl(Debug_dFile);
  937.             WriteTab(*d);
  938.             IO_WriteS(Debug_dFile, (STRING)": :", 3L);
  939.             IO_WriteNl(Debug_dFile);
  940.             d1 = 1;
  941.           }
  942.           p = Automaton_ItemArrayPtr->A[W_25->path->A[i - 1] - 1].Prod;
  943.           l = Automaton_ItemArrayPtr->A[W_25->path->A[i - 1] - 1].Pos;
  944.           WriteTab(*d);
  945.           IO_WriteC(Debug_dFile, ':');
  946.           WriteTab(d1);
  947.           WriteProd(p, l, &d1);
  948.           IO_WriteNl(Debug_dFile);
  949.           if (i >= B_26) break;
  950.         }
  951.     }
  952.   }
  953.   WriteTab(*d);
  954.   IO_WriteC(Debug_dFile, ':');
  955.   IO_WriteNl(Debug_dFile);
  956. }
  957.  
  958. static void WritePartC
  959. # ifdef __STDC__
  960. (CARDINAL *d, Automaton_tItemIndex I, TokenTab_Terminal t)
  961. # else
  962. (d, I, t)
  963. CARDINAL *d;
  964. Automaton_tItemIndex I;
  965. TokenTab_Terminal t;
  966. # endif
  967. {
  968.   CARDINAL i, j;
  969.   Automaton_tProdIndex p;
  970.   CARDINAL l;
  971.   Automaton_tProduction prod;
  972.   CARDINAL d1;
  973.  
  974.   {
  975.     register tItemPath *W_26 = &PathC;
  976.  
  977.     for (i = W_26->count - 1; i >= 1; i += -1) {
  978.       if (*d > MaxTabC) {
  979.         WriteTab((LONGCARD)InitTab);
  980.         {
  981.           LONGCARD B_29 = InitTab + 1, B_30 = *d;
  982.  
  983.           if (B_29 <= B_30)
  984.             for (j = B_29;; j += 1) {
  985.               IO_WriteC(Debug_dFile, '.');
  986.               if (j >= B_30) break;
  987.             }
  988.         }
  989.         IO_WriteC(Debug_dFile, ':');
  990.         IO_WriteNl(Debug_dFile);
  991.         *d = InitTab;
  992.         WriteTab(*d);
  993.         IO_WriteC(Debug_dFile, ':');
  994.         IO_WriteNl(Debug_dFile);
  995.       }
  996.       p = Automaton_ItemArrayPtr->A[W_26->path->A[i - 1] - 1].Prod;
  997.       l = Automaton_ItemArrayPtr->A[W_26->path->A[i - 1] - 1].Pos;
  998.       WriteTab(*d);
  999.       WriteProd(p, l, d);
  1000.       IO_WriteNl(Debug_dFile);
  1001.     }
  1002.   }
  1003.   prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[Automaton_ItemArrayPtr->A[I - 1].Prod]);
  1004.   d1 = *d;
  1005.   p = Automaton_ItemArrayPtr->A[I - 1].Prod;
  1006.   l = Automaton_ItemArrayPtr->A[I - 1].Pos;
  1007.   WriteTab(d1);
  1008.   WriteProd(p, l, &d1);
  1009.   IO_WriteNl(Debug_dFile);
  1010.   l = VocLength(prod->Left);
  1011.   if (*d >= 4 + 7 + l) {
  1012.     DEC1(*d, 4 + 7 + l);
  1013.   } else {
  1014.     WriteTab(*d);
  1015.     IO_WriteC(Debug_dFile, ':');
  1016.     {
  1017.       LONGCARD B_31 = *d + 1, B_32 = 4 + 7 + l;
  1018.  
  1019.       if (B_31 <= B_32)
  1020.         for (j = B_31;; j += 1) {
  1021.           IO_WriteC(Debug_dFile, '.');
  1022.           if (j >= B_32) break;
  1023.         }
  1024.     }
  1025.     IO_WriteNl(Debug_dFile);
  1026.     WriteTab(4 + 7 + l);
  1027.     IO_WriteC(Debug_dFile, ':');
  1028.     IO_WriteNl(Debug_dFile);
  1029.     *d = 0;
  1030.   }
  1031.   {
  1032.     register struct Automaton_9 *W_27 = prod;
  1033.  
  1034.     WriteTab(*d);
  1035.     IO_WriteS(Debug_dFile, (STRING)"reduce ", 7L);
  1036.     WriteVoc(W_27->Left, &l);
  1037.     IO_WriteS(Debug_dFile, (STRING)" -> ", 4L);
  1038.     if (W_27->Len == 0) {
  1039.       IO_WriteS(Debug_dFile, (STRING)"-Epsilon-", 9L);
  1040.     } else {
  1041.       {
  1042.         LONGCARD B_33 = 1, B_34 = W_27->Len;
  1043.  
  1044.         if (B_33 <= B_34)
  1045.           for (i = B_33;; i += 1) {
  1046.             WriteVoc(W_27->Right.A[i - 1], &l);
  1047.             if (i < W_27->Len) {
  1048.               IO_WriteC(Debug_dFile, ' ');
  1049.             }
  1050.             if (i >= B_34) break;
  1051.           }
  1052.       }
  1053.     }
  1054.     IO_WriteS(Debug_dFile, (STRING)". {", 3L);
  1055.     WriteVoc(t, &l);
  1056.     IO_WriteS(Debug_dFile, (STRING)"} ?", 3L);
  1057.     IO_WriteNl(Debug_dFile);
  1058.   }
  1059. }
  1060.  
  1061. static void WritePartD
  1062. # ifdef __STDC__
  1063. (CARDINAL dist, Automaton_tStateIndex State, TokenTab_Terminal t, Automaton_tItemIndex RedItem, Sets_tSet EI)
  1064. # else
  1065. (dist, State, t, RedItem, EI)
  1066. CARDINAL dist;
  1067. Automaton_tStateIndex State;
  1068. TokenTab_Terminal t;
  1069. Automaton_tItemIndex RedItem;
  1070. Sets_tSet EI;
  1071. # endif
  1072. {
  1073.   Automaton_tItemIndex Item;
  1074.   Automaton_tProduction prod;
  1075.   CARDINAL i, j, l;
  1076.   CARDINAL d;
  1077.   Automaton_tProduction RedProd;
  1078.  
  1079.   RedProd = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[Automaton_ItemArrayPtr->A[RedItem - 1].Prod]);
  1080.   {
  1081.     register Automaton_tState *W_28 = &Automaton_StateArrayPtr->A[State - 1];
  1082.  
  1083.     {
  1084.       LONGCARD B_35 = W_28->Items, B_36 = W_28->Items + W_28->Size - 1;
  1085.  
  1086.       if (B_35 <= B_36)
  1087.         for (Item = B_35;; Item += 1) {
  1088.           {
  1089.             register Automaton_tItem *W_29 = &Automaton_ItemArrayPtr->A[Item - 1];
  1090.  
  1091.             if (W_29->Read == t && !Sets_IsElement(Item - W_28->Items, &EI)) {
  1092.               Sets_Include(&EI, Item - W_28->Items);
  1093.               d = InitTab;
  1094.               prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_29->Prod]);
  1095.               {
  1096.                 register struct Automaton_9 *W_30 = prod;
  1097.  
  1098.                 if (W_29->Pos != Automaton_ItemArrayPtr->A[RedItem - 1].Pos || W_30->Left != RedProd->Left) {
  1099.                   IO_WriteNl(Debug_dFile);
  1100.                   FindPathD(W_30->Left, State);
  1101.                   {
  1102.                     register tProdPath *W_31 = &PathD;
  1103.  
  1104.                     {
  1105.                       LONGCARD B_37 = 1, B_38 = W_31->count - 1;
  1106.  
  1107.                       if (B_37 <= B_38)
  1108.                         for (i = B_37;; i += 1) {
  1109.                           WriteTab(d);
  1110.                           WriteProd(W_31->path->A[i - 1].Prod, W_31->path->A[i - 1].Pos, &d);
  1111.                           IO_WriteNl(Debug_dFile);
  1112.                           if (d > MaxTabD) {
  1113.                             WriteTab((LONGCARD)InitTab);
  1114.                             {
  1115.                               LONGCARD B_39 = InitTab + 1, B_40 = d;
  1116.  
  1117.                               if (B_39 <= B_40)
  1118.                                 for (j = B_39;; j += 1) {
  1119.                                   IO_WriteC(Debug_dFile, '.');
  1120.                                   if (j >= B_40) break;
  1121.                                 }
  1122.                             }
  1123.                             IO_WriteC(Debug_dFile, ':');
  1124.                             IO_WriteNl(Debug_dFile);
  1125.                             d = InitTab;
  1126.                             WriteTab(d);
  1127.                             IO_WriteC(Debug_dFile, ':');
  1128.                             IO_WriteNl(Debug_dFile);
  1129.                           }
  1130.                           if (i >= B_38) break;
  1131.                         }
  1132.                     }
  1133.                   }
  1134.                   DynArray_ReleaseArray((ADDRESS *)&PathD.path, &PathD.max, (LONGINT)sizeof(tProdPathElmt));
  1135.                   WriteTab(d);
  1136.                   WriteProd(W_29->Prod, 0L, &d);
  1137.                   IO_WriteNl(Debug_dFile);
  1138.                   l = VocLength(W_30->Left);
  1139.                   if (d >= 4 + 7 + l) {
  1140.                     DEC1(d, 4 + 7 + l);
  1141.                   } else {
  1142.                     WriteTab(d);
  1143.                     IO_WriteC(Debug_dFile, ':');
  1144.                     {
  1145.                       LONGCARD B_41 = d + 1, B_42 = 4 + 7 + l;
  1146.  
  1147.                       if (B_41 <= B_42)
  1148.                         for (j = B_41;; j += 1) {
  1149.                           IO_WriteC(Debug_dFile, '.');
  1150.                           if (j >= B_42) break;
  1151.                         }
  1152.                     }
  1153.                     IO_WriteNl(Debug_dFile);
  1154.                     WriteTab(4 + 7 + l);
  1155.                     IO_WriteC(Debug_dFile, ':');
  1156.                     IO_WriteNl(Debug_dFile);
  1157.                     d = 0;
  1158.                   }
  1159.                 } else {
  1160.                   d = dist;
  1161.                 }
  1162.                 WriteTab(d);
  1163.                 IO_WriteS(Debug_dFile, (STRING)"read   ", 7L);
  1164.                 WriteVoc(W_30->Left, &l);
  1165.                 IO_WriteS(Debug_dFile, (STRING)" -> ", 4L);
  1166.                 if (W_29->Pos == 0) {
  1167.                   IO_WriteC(Debug_dFile, '.');
  1168.                 }
  1169.                 {
  1170.                   LONGCARD B_43 = 1, B_44 = W_30->Len;
  1171.  
  1172.                   if (B_43 <= B_44)
  1173.                     for (i = B_43;; i += 1) {
  1174.                       WriteVoc(W_30->Right.A[i - 1], &l);
  1175.                       if (i == W_29->Pos) {
  1176.                         IO_WriteC(Debug_dFile, '.');
  1177.                       } else if (i < W_30->Len) {
  1178.                         IO_WriteC(Debug_dFile, ' ');
  1179.                       }
  1180.                       if (i >= B_44) break;
  1181.                     }
  1182.                 }
  1183.                 IO_WriteS(Debug_dFile, (STRING)" ?", 2L);
  1184.               }
  1185.               IO_WriteNl(Debug_dFile);
  1186.             }
  1187.           }
  1188.           if (Item >= B_36) break;
  1189.         }
  1190.     }
  1191.   }
  1192. }
  1193.  
  1194. static void PutInChain
  1195. # ifdef __STDC__
  1196. (Automaton_tItemIndex Item, Automaton_tIndex Last)
  1197. # else
  1198. (Item, Last)
  1199. Automaton_tItemIndex Item;
  1200. Automaton_tIndex Last;
  1201. # endif
  1202. {
  1203.   Automaton_tProduction prod;
  1204.   Automaton_tStateIndex State;
  1205.   Automaton_tItemIndex I;
  1206.  
  1207.   prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[Automaton_ItemArrayPtr->A[Item - 1].Prod]);
  1208.   while (Automaton_ItemArrayPtr->A[Item - 1].Pos < prod->Len && !Sets_IsElement(Item, &ChainD.reached)) {
  1209.     {
  1210.       register tItemChain *W_32 = &ChainD;
  1211.  
  1212.       INC(W_32->count);
  1213.       if (W_32->count > W_32->max) {
  1214.         DynArray_ExtendArray((ADDRESS *)&W_32->chain, &W_32->max, (LONGINT)sizeof(tItemChainElmt));
  1215.       }
  1216.       W_32->chain->A[W_32->count - 1].Last = Last;
  1217.       W_32->chain->A[W_32->count - 1].Item = Item;
  1218.       Sets_Include(&W_32->reached, Item);
  1219.     }
  1220.     State = Automaton_ItemArrayPtr->A[Item - 1].Next;
  1221.     I = Automaton_StateArrayPtr->A[State - 1].Items;
  1222.     while (Automaton_ItemArrayPtr->A[I - 1].Prod != Automaton_ItemArrayPtr->A[Item - 1].Prod || Automaton_ItemArrayPtr->A[I - 1].Pos != Automaton_ItemArrayPtr->A[Item - 1].Pos + 1) {
  1223.       INC(I);
  1224.     }
  1225.     Item = I;
  1226.   }
  1227. }
  1228.  
  1229. static void MakeChainD
  1230. # ifdef __STDC__
  1231. ()
  1232. # else
  1233. ()
  1234. # endif
  1235. {
  1236.   LONGINT LastCount;
  1237.   Automaton_tItemIndex Item, I;
  1238.   Automaton_tStateIndex State;
  1239.   TokenTab_Vocabulary read;
  1240.   Automaton_tProduction prod;
  1241.  
  1242.   {
  1243.     register tItemChain *W_33 = &ChainD;
  1244.  
  1245.     W_33->max = InitChainLength;
  1246.     W_33->count = 0;
  1247.     W_33->level = 0;
  1248.     DynArray_MakeArray((ADDRESS *)&W_33->chain, &W_33->max, (LONGINT)sizeof(tItemChainElmt));
  1249.     Sets_MakeSet(&W_33->reached, (LONGCARD)Automaton_ItemIndex);
  1250.     PutInChain(1L, 0L);
  1251.     for (;;) {
  1252.       {
  1253.         register tItemChain *W_34 = &ChainD;
  1254.  
  1255.         LastCount = W_34->count;
  1256.         if (W_34->level == LastCount) {
  1257.           goto EXIT_3;
  1258.         }
  1259.         while (W_34->level < LastCount) {
  1260.           INC(W_34->level);
  1261.           Item = W_34->chain->A[W_34->level - 1].Item;
  1262.           read = Automaton_ItemArrayPtr->A[Item - 1].Read;
  1263.           if (read >= TokenTab_MINNonTerm && read <= TokenTab_MAXNonTerm) {
  1264.             State = Automaton_ItemArrayPtr->A[Item - 1].Number;
  1265.             {
  1266.               LONGCARD B_45 = Automaton_StateArrayPtr->A[State - 1].Items, B_46 = Automaton_StateArrayPtr->A[State - 1].Items + Automaton_StateArrayPtr->A[State - 1].Size - 1;
  1267.  
  1268.               if (B_45 <= B_46)
  1269.                 for (I = B_45;; I += 1) {
  1270.                   {
  1271.                     register Automaton_tItem *W_35 = &Automaton_ItemArrayPtr->A[I - 1];
  1272.  
  1273.                     prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_35->Prod]);
  1274.                     if (prod->Left == read && Automaton_ItemArrayPtr->A[I - 1].Pos == 0) {
  1275.                       PutInChain(I, (LONGCARD)W_34->level);
  1276.                     }
  1277.                   }
  1278.                   if (I >= B_46) break;
  1279.                 }
  1280.             }
  1281.           }
  1282.         }
  1283.       }
  1284.     } EXIT_3:;
  1285.   }
  1286. }
  1287.  
  1288. static void FindPathD
  1289. # ifdef __STDC__
  1290. (TokenTab_NonTerminal NT, Automaton_tStateIndex EndState)
  1291. # else
  1292. (NT, EndState)
  1293. TokenTab_NonTerminal NT;
  1294. Automaton_tStateIndex EndState;
  1295. # endif
  1296. {
  1297.   LONGINT last, level;
  1298.   Automaton_tProduction prod;
  1299.   Automaton_tItemIndex I;
  1300.   Automaton_tIndex Depth;
  1301.  
  1302.   if (ChainD.max == 0) {
  1303.     MakeChainD();
  1304.   }
  1305.   {
  1306.     register tItemChain *W_36 = &ChainD;
  1307.  
  1308.     last = 0;
  1309.     for (;;) {
  1310.       INC(last);
  1311.       I = W_36->chain->A[last - 1].Item;
  1312.       if (Automaton_ItemArrayPtr->A[I - 1].Number == EndState) {
  1313.         prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[Automaton_ItemArrayPtr->A[I - 1].Prod]);
  1314.         if (NT == prod->Left) {
  1315.           goto EXIT_4;
  1316.         }
  1317.       }
  1318.     } EXIT_4:;
  1319.     Depth = 0;
  1320.     W_36->level = last;
  1321.     while (W_36->level != 0) {
  1322.       INC(Depth);
  1323.       W_36->level = W_36->chain->A[W_36->level - 1].Last;
  1324.     }
  1325.     {
  1326.       register tProdPath *W_37 = &PathD;
  1327.  
  1328.       W_37->count = Depth;
  1329.       W_37->max = Depth;
  1330.       DynArray_MakeArray((ADDRESS *)&W_37->path, &W_37->max, (LONGINT)sizeof(tProdPathElmt));
  1331.     }
  1332.     W_36->level = last;
  1333.     while (Depth > 0) {
  1334.       I = W_36->chain->A[W_36->level - 1].Item;
  1335.       PathD.path->A[Depth - 1].Prod = Automaton_ItemArrayPtr->A[I - 1].Prod;
  1336.       PathD.path->A[Depth - 1].Pos = Automaton_ItemArrayPtr->A[I - 1].Pos;
  1337.       DEC(Depth);
  1338.       W_36->level = W_36->chain->A[W_36->level - 1].Last;
  1339.     }
  1340.   }
  1341. }
  1342.  
  1343. static void WriteProd
  1344. # ifdef __STDC__
  1345. (Automaton_tProdIndex p, Automaton_tIndex l, CARDINAL *d)
  1346. # else
  1347. (p, l, d)
  1348. Automaton_tProdIndex p;
  1349. Automaton_tIndex l;
  1350. CARDINAL *d;
  1351. # endif
  1352. {
  1353.   Automaton_tProduction prod;
  1354.   Automaton_tIndex i;
  1355.   CARDINAL length;
  1356.  
  1357.   prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[p]);
  1358.   {
  1359.     register struct Automaton_9 *W_38 = prod;
  1360.  
  1361.     if (W_38->Len == 0) {
  1362.       IO_WriteS(Debug_dFile, (STRING)"-Epsilon-", 9L);
  1363.     } else {
  1364.       {
  1365.         LONGCARD B_47 = 1, B_48 = W_38->Len;
  1366.  
  1367.         if (B_47 <= B_48)
  1368.           for (i = B_47;; i += 1) {
  1369.             WriteVoc(W_38->Right.A[i - 1], &length);
  1370.             IO_WriteS(Debug_dFile, (STRING)" ", 1L);
  1371.             if (i <= l) {
  1372.               INC1(*d, length + 1);
  1373.             }
  1374.             if (i >= B_48) break;
  1375.           }
  1376.       }
  1377.     }
  1378.   }
  1379. }
  1380.  
  1381. static void WriteVoc
  1382. # ifdef __STDC__
  1383. (TokenTab_Vocabulary voc, CARDINAL *length)
  1384. # else
  1385. (voc, length)
  1386. TokenTab_Vocabulary voc;
  1387. CARDINAL *length;
  1388. # endif
  1389. {
  1390.   Idents_tIdent sym;
  1391.   Strings_tString str;
  1392.   TokenTab_TokenError err;
  1393.   CARDINAL i;
  1394.  
  1395.   sym = TokenTab_TokenToSymbol(voc, &err);
  1396.   Idents_GetString(sym, &str);
  1397.   *length = Strings_Length(&str);
  1398.   {
  1399.     LONGCARD B_49 = 1, B_50 = *length;
  1400.  
  1401.     if (B_49 <= B_50)
  1402.       for (i = B_49;; i += 1) {
  1403.         IO_WriteC(Debug_dFile, Strings_Char(&str, (Strings_tStringIndex)i));
  1404.         if (i >= B_50) break;
  1405.       }
  1406.   }
  1407. }
  1408.  
  1409. static CARDINAL VocLength
  1410. # ifdef __STDC__
  1411. (TokenTab_Vocabulary voc)
  1412. # else
  1413. (voc)
  1414. TokenTab_Vocabulary voc;
  1415. # endif
  1416. {
  1417.   Idents_tIdent sym;
  1418.   Strings_tString str;
  1419.   TokenTab_TokenError err;
  1420.  
  1421.   sym = TokenTab_TokenToSymbol(voc, &err);
  1422.   Idents_GetString(sym, &str);
  1423.   return Strings_Length(&str);
  1424. }
  1425.  
  1426. static void WriteTab
  1427. # ifdef __STDC__
  1428. (CARDINAL d)
  1429. # else
  1430. (d)
  1431. CARDINAL d;
  1432. # endif
  1433. {
  1434.   CARDINAL i;
  1435.  
  1436.   {
  1437.     LONGCARD B_51 = 1, B_52 = d;
  1438.  
  1439.     if (B_51 <= B_52)
  1440.       for (i = B_51;; i += 1) {
  1441.         IO_WriteC(Debug_dFile, ' ');
  1442.         if (i >= B_52) break;
  1443.       }
  1444.   }
  1445. }
  1446.  
  1447. void BEGIN_Debug()
  1448. {
  1449.   static BOOLEAN has_been_called = FALSE;
  1450.  
  1451.   if (!has_been_called) {
  1452.     has_been_called = TRUE;
  1453.  
  1454.     BEGIN_IO();
  1455.     BEGIN_Sets();
  1456.     BEGIN_Automaton();
  1457.     BEGIN_TokenTab();
  1458.     BEGIN_Automaton();
  1459.     BEGIN_Continue();
  1460.     BEGIN_DynArray();
  1461.     BEGIN_IO();
  1462.     BEGIN_Sets();
  1463.     BEGIN_Strings();
  1464.     BEGIN_Idents();
  1465.     BEGIN_TokenTab();
  1466.  
  1467.     Debug_NoTrace = FALSE;
  1468.     ChainD.max = 0;
  1469.   }
  1470. }
  1471.